// $ANTLR 3.2 Sep 23, 2009 12:02:23 C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g 2010-02-11 14:47:17

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;


public partial class ExprLexer : Lexer {
    public const int LT = 14;
    public const int MODULO = 22;
    public const int LTEQ = 15;
    public const int NUMBER = 25;
    public const int CHAR = 26;
    public const int POWER = 23;
    public const int NEGATE = 4;
    public const int NOTEQUALS = 13;
    public const int CONDITION = 5;
    public const int EQUALS = 12;
    public const int SEPARATOR = 6;
    public const int NOT = 24;
    public const int MINUS = 19;
    public const int GTEQ = 17;
    public const int AND = 10;
    public const int EOF = -1;
    public const int HexDigit = 29;
    public const int T__30 = 30;
    public const int T__31 = 31;
    public const int T__32 = 32;
    public const int WS = 9;
    public const int T__33 = 33;
    public const int MULTIPLY = 20;
    public const int UnicodeEscape = 28;
    public const int OR = 11;
    public const int ASSIGN = 8;
    public const int IDENT = 7;
    public const int GT = 16;
    public const int PLUS = 18;
    public const int EscapeSequence = 27;
    public const int DIVIDE = 21;

    // delegates
    // delegators

    public ExprLexer() 
    {
		InitializeCyclicDFAs();
    }
    public ExprLexer(ICharStream input)
		: this(input, null) {
    }
    public ExprLexer(ICharStream input, RecognizerSharedState state)
		: base(input, state) {
		InitializeCyclicDFAs(); 

    }
    
    override public string GrammarFileName
    {
    	get { return "C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g";} 
    }

    // $ANTLR start "T__30"
    public void mT__30() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__30;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:7:7: ( '?' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:7:9: '?'
            {
            	Match('?'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__30"

    // $ANTLR start "T__31"
    public void mT__31() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__31;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:8:7: ( ':' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:8:9: ':'
            {
            	Match(':'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__31"

    // $ANTLR start "T__32"
    public void mT__32() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__32;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:9:7: ( '(' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:9:9: '('
            {
            	Match('('); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__32"

    // $ANTLR start "T__33"
    public void mT__33() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = T__33;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:10:7: ( ')' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:10:9: ')'
            {
            	Match(')'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "T__33"

    // $ANTLR start "ASSIGN"
    public void mASSIGN() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = ASSIGN;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:70:9: ( '=' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:70:11: '='
            {
            	Match('='); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "ASSIGN"

    // $ANTLR start "AND"
    public void mAND() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = AND;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:72:7: ( '&&' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:72:9: '&&'
            {
            	Match("&&"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "AND"

    // $ANTLR start "OR"
    public void mOR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = OR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:73:6: ( '||' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:73:8: '||'
            {
            	Match("||"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "OR"

    // $ANTLR start "EQUALS"
    public void mEQUALS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = EQUALS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:75:9: ( '==' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:75:11: '=='
            {
            	Match("=="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "EQUALS"

    // $ANTLR start "NOTEQUALS"
    public void mNOTEQUALS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = NOTEQUALS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:76:11: ( '!=' | '<>' )
            int alt1 = 2;
            int LA1_0 = input.LA(1);

            if ( (LA1_0 == '!') )
            {
                alt1 = 1;
            }
            else if ( (LA1_0 == '<') )
            {
                alt1 = 2;
            }
            else 
            {
                NoViableAltException nvae_d1s0 =
                    new NoViableAltException("", 1, 0, input);

                throw nvae_d1s0;
            }
            switch (alt1) 
            {
                case 1 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:76:13: '!='
                    {
                    	Match("!="); 


                    }
                    break;
                case 2 :
                    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:76:20: '<>'
                    {
                    	Match("<>"); 


                    }
                    break;

            }
            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "NOTEQUALS"

    // $ANTLR start "LT"
    public void mLT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = LT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:78:6: ( '<' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:78:8: '<'
            {
            	Match('<'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "LT"

    // $ANTLR start "LTEQ"
    public void mLTEQ() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = LTEQ;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:79:7: ( '<=' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:79:9: '<='
            {
            	Match("<="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "LTEQ"

    // $ANTLR start "GT"
    public void mGT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = GT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:80:6: ( '>' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:80:8: '>'
            {
            	Match('>'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "GT"

    // $ANTLR start "GTEQ"
    public void mGTEQ() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = GTEQ;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:81:7: ( '>=' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:81:9: '>='
            {
            	Match(">="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "GTEQ"

    // $ANTLR start "PLUS"
    public void mPLUS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = PLUS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:83:7: ( '+' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:83:9: '+'
            {
            	Match('+'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "PLUS"

    // $ANTLR start "MINUS"
    public void mMINUS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = MINUS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:84:8: ( '-' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:84:10: '-'
            {
            	Match('-'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "MINUS"

    // $ANTLR start "MULTIPLY"
    public void mMULTIPLY() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = MULTIPLY;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:86:10: ( '*' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:86:12: '*'
            {
            	Match('*'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "MULTIPLY"

    // $ANTLR start "DIVIDE"
    public void mDIVIDE() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = DIVIDE;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:87:9: ( '/' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:87:11: '/'
            {
            	Match('/'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "DIVIDE"

    // $ANTLR start "MODULO"
    public void mMODULO() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = MODULO;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:88:9: ( '%' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:88:11: '%'
            {
            	Match('%'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "MODULO"

    // $ANTLR start "POWER"
    public void mPOWER() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = POWER;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:90:8: ( '^' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:90:10: '^'
            {
            	Match('^'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "POWER"

    // $ANTLR start "NOT"
    public void mNOT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = NOT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:92:7: ( '!' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:92:9: '!'
            {
            	Match('!'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "NOT"

    // $ANTLR start "CHAR"
    public void mCHAR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = CHAR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:96:10: ( '\\'' ( EscapeSequence | ( options {greedy=false; } : ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' ) ) ) '\\'' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:96:14: '\\'' ( EscapeSequence | ( options {greedy=false; } : ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' ) ) ) '\\''
            {
            	Match('\''); 
            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:96:19: ( EscapeSequence | ( options {greedy=false; } : ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' ) ) )
            	int alt2 = 2;
            	int LA2_0 = input.LA(1);

            	if ( (LA2_0 == '\\') )
            	{
            	    alt2 = 1;
            	}
            	else if ( ((LA2_0 >= ' ' && LA2_0 <= '&') || (LA2_0 >= '(' && LA2_0 <= '[') || (LA2_0 >= ']' && LA2_0 <= '\uFFFF')) )
            	{
            	    alt2 = 2;
            	}
            	else 
            	{
            	    NoViableAltException nvae_d2s0 =
            	        new NoViableAltException("", 2, 0, input);

            	    throw nvae_d2s0;
            	}
            	switch (alt2) 
            	{
            	    case 1 :
            	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:96:21: EscapeSequence
            	        {
            	        	mEscapeSequence(); 

            	        }
            	        break;
            	    case 2 :
            	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:96:38: ( options {greedy=false; } : ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' ) )
            	        {
            	        	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:96:38: ( options {greedy=false; } : ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' ) )
            	        	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:96:65: ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' )
            	        	{
            	        		if ( (input.LA(1) >= ' ' && input.LA(1) <= '&') || (input.LA(1) >= '(' && input.LA(1) <= '[') || (input.LA(1) >= ']' && input.LA(1) <= '\uFFFF') ) 
            	        		{
            	        		    input.Consume();

            	        		}
            	        		else 
            	        		{
            	        		    MismatchedSetException mse = new MismatchedSetException(null,input);
            	        		    Recover(mse);
            	        		    throw mse;}


            	        	}


            	        }
            	        break;

            	}

            	Match('\''); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "CHAR"

    // $ANTLR start "EscapeSequence"
    public void mEscapeSequence() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:99:4: ( '\\\\' ( 'n' | 'r' | 't' | '\\'' | '\\\\' | UnicodeEscape ) )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:99:6: '\\\\' ( 'n' | 'r' | 't' | '\\'' | '\\\\' | UnicodeEscape )
            {
            	Match('\\'); 
            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:99:11: ( 'n' | 'r' | 't' | '\\'' | '\\\\' | UnicodeEscape )
            	int alt3 = 6;
            	switch ( input.LA(1) ) 
            	{
            	case 'n':
            		{
            	    alt3 = 1;
            	    }
            	    break;
            	case 'r':
            		{
            	    alt3 = 2;
            	    }
            	    break;
            	case 't':
            		{
            	    alt3 = 3;
            	    }
            	    break;
            	case '\'':
            		{
            	    alt3 = 4;
            	    }
            	    break;
            	case '\\':
            		{
            	    alt3 = 5;
            	    }
            	    break;
            	case 'u':
            		{
            	    alt3 = 6;
            	    }
            	    break;
            		default:
            		    NoViableAltException nvae_d3s0 =
            		        new NoViableAltException("", 3, 0, input);

            		    throw nvae_d3s0;
            	}

            	switch (alt3) 
            	{
            	    case 1 :
            	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:99:12: 'n'
            	        {
            	        	Match('n'); 

            	        }
            	        break;
            	    case 2 :
            	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:99:18: 'r'
            	        {
            	        	Match('r'); 

            	        }
            	        break;
            	    case 3 :
            	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:99:24: 't'
            	        {
            	        	Match('t'); 

            	        }
            	        break;
            	    case 4 :
            	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:99:30: '\\''
            	        {
            	        	Match('\''); 

            	        }
            	        break;
            	    case 5 :
            	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:99:37: '\\\\'
            	        {
            	        	Match('\\'); 

            	        }
            	        break;
            	    case 6 :
            	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:99:44: UnicodeEscape
            	        {
            	        	mUnicodeEscape(); 

            	        }
            	        break;

            	}


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "EscapeSequence"

    // $ANTLR start "UnicodeEscape"
    public void mUnicodeEscape() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:102:7: ( 'u' HexDigit HexDigit HexDigit HexDigit )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:102:13: 'u' HexDigit HexDigit HexDigit HexDigit
            {
            	Match('u'); 
            	mHexDigit(); 
            	mHexDigit(); 
            	mHexDigit(); 
            	mHexDigit(); 

            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "UnicodeEscape"

    // $ANTLR start "HexDigit"
    public void mHexDigit() // throws RecognitionException [2]
    {
    		try
    		{
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:105:4: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:105:7: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
            {
            	if ( (input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA(1) <= 'F') || (input.LA(1) >= 'a' && input.LA(1) <= 'f') ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}


            }

        }
        finally 
    	{
        }
    }
    // $ANTLR end "HexDigit"

    // $ANTLR start "IDENT"
    public void mIDENT() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = IDENT;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:107:8: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:107:10: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
            {
            	if ( (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            	{
            	    input.Consume();

            	}
            	else 
            	{
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    Recover(mse);
            	    throw mse;}

            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:107:38: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
            	do 
            	{
            	    int alt4 = 2;
            	    int LA4_0 = input.LA(1);

            	    if ( ((LA4_0 >= '0' && LA4_0 <= '9') || (LA4_0 >= 'A' && LA4_0 <= 'Z') || LA4_0 == '_' || (LA4_0 >= 'a' && LA4_0 <= 'z')) )
            	    {
            	        alt4 = 1;
            	    }


            	    switch (alt4) 
            		{
            			case 1 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:
            			    {
            			    	if ( (input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z') ) 
            			    	{
            			    	    input.Consume();

            			    	}
            			    	else 
            			    	{
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    Recover(mse);
            			    	    throw mse;}


            			    }
            			    break;

            			default:
            			    goto loop4;
            	    }
            	} while (true);

            	loop4:
            		;	// Stops C# compiler whining that label 'loop4' has no statements


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "IDENT"

    // $ANTLR start "NUMBER"
    public void mNUMBER() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = NUMBER;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:108:9: ( ( ( '0' .. '9' )* '.' )? ( '0' .. '9' )+ )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:108:11: ( ( '0' .. '9' )* '.' )? ( '0' .. '9' )+
            {
            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:108:11: ( ( '0' .. '9' )* '.' )?
            	int alt6 = 2;
            	alt6 = dfa6.Predict(input);
            	switch (alt6) 
            	{
            	    case 1 :
            	        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:108:12: ( '0' .. '9' )* '.'
            	        {
            	        	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:108:12: ( '0' .. '9' )*
            	        	do 
            	        	{
            	        	    int alt5 = 2;
            	        	    int LA5_0 = input.LA(1);

            	        	    if ( ((LA5_0 >= '0' && LA5_0 <= '9')) )
            	        	    {
            	        	        alt5 = 1;
            	        	    }


            	        	    switch (alt5) 
            	        		{
            	        			case 1 :
            	        			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:108:13: '0' .. '9'
            	        			    {
            	        			    	MatchRange('0','9'); 

            	        			    }
            	        			    break;

            	        			default:
            	        			    goto loop5;
            	        	    }
            	        	} while (true);

            	        	loop5:
            	        		;	// Stops C# compiler whining that label 'loop5' has no statements

            	        	Match('.'); 

            	        }
            	        break;

            	}

            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:108:30: ( '0' .. '9' )+
            	int cnt7 = 0;
            	do 
            	{
            	    int alt7 = 2;
            	    int LA7_0 = input.LA(1);

            	    if ( ((LA7_0 >= '0' && LA7_0 <= '9')) )
            	    {
            	        alt7 = 1;
            	    }


            	    switch (alt7) 
            		{
            			case 1 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:108:31: '0' .. '9'
            			    {
            			    	MatchRange('0','9'); 

            			    }
            			    break;

            			default:
            			    if ( cnt7 >= 1 ) goto loop7;
            		            EarlyExitException eee7 =
            		                new EarlyExitException(7, input);
            		            throw eee7;
            	    }
            	    cnt7++;
            	} while (true);

            	loop7:
            		;	// Stops C# compiler whining that label 'loop7' has no statements


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "NUMBER"

    // $ANTLR start "SEPARATOR"
    public void mSEPARATOR() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = SEPARATOR;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:109:11: ( ';' )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:109:13: ';'
            {
            	Match(';'); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "SEPARATOR"

    // $ANTLR start "WS"
    public void mWS() // throws RecognitionException [2]
    {
    		try
    		{
            int _type = WS;
    	int _channel = DEFAULT_TOKEN_CHANNEL;
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:110:6: ( ( ' ' | '\\t' | ( ( '\\r' )? '\\n' ) )+ )
            // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:110:8: ( ' ' | '\\t' | ( ( '\\r' )? '\\n' ) )+
            {
            	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:110:8: ( ' ' | '\\t' | ( ( '\\r' )? '\\n' ) )+
            	int cnt9 = 0;
            	do 
            	{
            	    int alt9 = 4;
            	    switch ( input.LA(1) ) 
            	    {
            	    case ' ':
            	    	{
            	        alt9 = 1;
            	        }
            	        break;
            	    case '\t':
            	    	{
            	        alt9 = 2;
            	        }
            	        break;
            	    case '\n':
            	    case '\r':
            	    	{
            	        alt9 = 3;
            	        }
            	        break;

            	    }

            	    switch (alt9) 
            		{
            			case 1 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:110:9: ' '
            			    {
            			    	Match(' '); 

            			    }
            			    break;
            			case 2 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:110:15: '\\t'
            			    {
            			    	Match('\t'); 

            			    }
            			    break;
            			case 3 :
            			    // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:110:22: ( ( '\\r' )? '\\n' )
            			    {
            			    	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:110:22: ( ( '\\r' )? '\\n' )
            			    	// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:110:23: ( '\\r' )? '\\n'
            			    	{
            			    		// C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:110:23: ( '\\r' )?
            			    		int alt8 = 2;
            			    		int LA8_0 = input.LA(1);

            			    		if ( (LA8_0 == '\r') )
            			    		{
            			    		    alt8 = 1;
            			    		}
            			    		switch (alt8) 
            			    		{
            			    		    case 1 :
            			    		        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:110:23: '\\r'
            			    		        {
            			    		        	Match('\r'); 

            			    		        }
            			    		        break;

            			    		}

            			    		Match('\n'); 

            			    	}


            			    }
            			    break;

            			default:
            			    if ( cnt9 >= 1 ) goto loop9;
            		            EarlyExitException eee9 =
            		                new EarlyExitException(9, input);
            		            throw eee9;
            	    }
            	    cnt9++;
            	} while (true);

            	loop9:
            		;	// Stops C# compiler whining that label 'loop9' has no statements

            	 Skip(); 

            }

            state.type = _type;
            state.channel = _channel;
        }
        finally 
    	{
        }
    }
    // $ANTLR end "WS"

    override public void mTokens() // throws RecognitionException 
    {
        // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:8: ( T__30 | T__31 | T__32 | T__33 | ASSIGN | AND | OR | EQUALS | NOTEQUALS | LT | LTEQ | GT | GTEQ | PLUS | MINUS | MULTIPLY | DIVIDE | MODULO | POWER | NOT | CHAR | IDENT | NUMBER | SEPARATOR | WS )
        int alt10 = 25;
        alt10 = dfa10.Predict(input);
        switch (alt10) 
        {
            case 1 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:10: T__30
                {
                	mT__30(); 

                }
                break;
            case 2 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:16: T__31
                {
                	mT__31(); 

                }
                break;
            case 3 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:22: T__32
                {
                	mT__32(); 

                }
                break;
            case 4 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:28: T__33
                {
                	mT__33(); 

                }
                break;
            case 5 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:34: ASSIGN
                {
                	mASSIGN(); 

                }
                break;
            case 6 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:41: AND
                {
                	mAND(); 

                }
                break;
            case 7 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:45: OR
                {
                	mOR(); 

                }
                break;
            case 8 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:48: EQUALS
                {
                	mEQUALS(); 

                }
                break;
            case 9 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:55: NOTEQUALS
                {
                	mNOTEQUALS(); 

                }
                break;
            case 10 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:65: LT
                {
                	mLT(); 

                }
                break;
            case 11 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:68: LTEQ
                {
                	mLTEQ(); 

                }
                break;
            case 12 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:73: GT
                {
                	mGT(); 

                }
                break;
            case 13 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:76: GTEQ
                {
                	mGTEQ(); 

                }
                break;
            case 14 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:81: PLUS
                {
                	mPLUS(); 

                }
                break;
            case 15 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:86: MINUS
                {
                	mMINUS(); 

                }
                break;
            case 16 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:92: MULTIPLY
                {
                	mMULTIPLY(); 

                }
                break;
            case 17 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:101: DIVIDE
                {
                	mDIVIDE(); 

                }
                break;
            case 18 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:108: MODULO
                {
                	mMODULO(); 

                }
                break;
            case 19 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:115: POWER
                {
                	mPOWER(); 

                }
                break;
            case 20 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:121: NOT
                {
                	mNOT(); 

                }
                break;
            case 21 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:125: CHAR
                {
                	mCHAR(); 

                }
                break;
            case 22 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:130: IDENT
                {
                	mIDENT(); 

                }
                break;
            case 23 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:136: NUMBER
                {
                	mNUMBER(); 

                }
                break;
            case 24 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:143: SEPARATOR
                {
                	mSEPARATOR(); 

                }
                break;
            case 25 :
                // C:\\Projects\\TomesLingo\\trunk\\ANTLR01\\ANTLR01\\Expr.g:1:153: WS
                {
                	mWS(); 

                }
                break;

        }

    }


    protected DFA6 dfa6;
    protected DFA10 dfa10;
	private void InitializeCyclicDFAs()
	{
	    this.dfa6 = new DFA6(this);
	    this.dfa10 = new DFA10(this);
	}

    const string DFA6_eotS =
        "\x01\uffff\x01\x03\x02\uffff";
    const string DFA6_eofS =
        "\x04\uffff";
    const string DFA6_minS =
        "\x02\x2e\x02\uffff";
    const string DFA6_maxS =
        "\x02\x39\x02\uffff";
    const string DFA6_acceptS =
        "\x02\uffff\x01\x01\x01\x02";
    const string DFA6_specialS =
        "\x04\uffff}>";
    static readonly string[] DFA6_transitionS = {
            "\x01\x02\x01\uffff\x0a\x01",
            "\x01\x02\x01\uffff\x0a\x01",
            "",
            ""
    };

    static readonly short[] DFA6_eot = DFA.UnpackEncodedString(DFA6_eotS);
    static readonly short[] DFA6_eof = DFA.UnpackEncodedString(DFA6_eofS);
    static readonly char[] DFA6_min = DFA.UnpackEncodedStringToUnsignedChars(DFA6_minS);
    static readonly char[] DFA6_max = DFA.UnpackEncodedStringToUnsignedChars(DFA6_maxS);
    static readonly short[] DFA6_accept = DFA.UnpackEncodedString(DFA6_acceptS);
    static readonly short[] DFA6_special = DFA.UnpackEncodedString(DFA6_specialS);
    static readonly short[][] DFA6_transition = DFA.UnpackEncodedStringArray(DFA6_transitionS);

    protected class DFA6 : DFA
    {
        public DFA6(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 6;
            this.eot = DFA6_eot;
            this.eof = DFA6_eof;
            this.min = DFA6_min;
            this.max = DFA6_max;
            this.accept = DFA6_accept;
            this.special = DFA6_special;
            this.transition = DFA6_transition;

        }

        override public string Description
        {
            get { return "108:11: ( ( '0' .. '9' )* '.' )?"; }
        }

    }

    const string DFA10_eotS =
        "\x05\uffff\x01\x17\x02\uffff\x01\x19\x01\x1b\x01\x1d\x13\uffff";
    const string DFA10_eofS =
        "\x1e\uffff";
    const string DFA10_minS =
        "\x01\x09\x04\uffff\x01\x3d\x02\uffff\x03\x3d\x13\uffff";
    const string DFA10_maxS =
        "\x01\x7c\x04\uffff\x01\x3d\x02\uffff\x01\x3d\x01\x3e\x01\x3d\x13"+
        "\uffff";
    const string DFA10_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\uffff\x01\x06\x01"+
        "\x07\x03\uffff\x01\x0e\x01\x0f\x01\x10\x01\x11\x01\x12\x01\x13\x01"+
        "\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x08\x01\x05\x01\x09\x01"+
        "\x14\x01\x0b\x01\x0a\x01\x0d\x01\x0c";
    const string DFA10_specialS =
        "\x1e\uffff}>";
    static readonly string[] DFA10_transitionS = {
            "\x02\x15\x02\uffff\x01\x15\x12\uffff\x01\x15\x01\x08\x03\uffff"+
            "\x01\x0f\x01\x06\x01\x11\x01\x03\x01\x04\x01\x0d\x01\x0b\x01"+
            "\uffff\x01\x0c\x01\x13\x01\x0e\x0a\x13\x01\x02\x01\x14\x01\x09"+
            "\x01\x05\x01\x0a\x01\x01\x01\uffff\x1a\x12\x03\uffff\x01\x10"+
            "\x01\x12\x01\uffff\x1a\x12\x01\uffff\x01\x07",
            "",
            "",
            "",
            "",
            "\x01\x16",
            "",
            "",
            "\x01\x18",
            "\x01\x1a\x01\x18",
            "\x01\x1c",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA10_eot = DFA.UnpackEncodedString(DFA10_eotS);
    static readonly short[] DFA10_eof = DFA.UnpackEncodedString(DFA10_eofS);
    static readonly char[] DFA10_min = DFA.UnpackEncodedStringToUnsignedChars(DFA10_minS);
    static readonly char[] DFA10_max = DFA.UnpackEncodedStringToUnsignedChars(DFA10_maxS);
    static readonly short[] DFA10_accept = DFA.UnpackEncodedString(DFA10_acceptS);
    static readonly short[] DFA10_special = DFA.UnpackEncodedString(DFA10_specialS);
    static readonly short[][] DFA10_transition = DFA.UnpackEncodedStringArray(DFA10_transitionS);

    protected class DFA10 : DFA
    {
        public DFA10(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 10;
            this.eot = DFA10_eot;
            this.eof = DFA10_eof;
            this.min = DFA10_min;
            this.max = DFA10_max;
            this.accept = DFA10_accept;
            this.special = DFA10_special;
            this.transition = DFA10_transition;

        }

        override public string Description
        {
            get { return "1:1: Tokens : ( T__30 | T__31 | T__32 | T__33 | ASSIGN | AND | OR | EQUALS | NOTEQUALS | LT | LTEQ | GT | GTEQ | PLUS | MINUS | MULTIPLY | DIVIDE | MODULO | POWER | NOT | CHAR | IDENT | NUMBER | SEPARATOR | WS );"; }
        }

    }

 
    
}
